COMMENT ⊗   VALID 00005 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 00002	ENTRY
C00003 00003	!	dimenstring
C00004 00004	! display: cvxs,cvxv,cvxr,cvxt,cvxf,cvxm,cvxp,cvxstr
C00009 00005	! cvx,cvsym,cvssym,cvexpr
C00013 ENDMK
C⊗;
ENTRY;
BEGIN "FORMAT"
DEFINE $FORMAT=TRUE;
REQUIRE "HEADER.SAI" SOURCE_FILE;

INTEGER ARRAY W[1:10],D[1:10];
INTEGER STPTR;

PROCEDURE SFORMAT(INTEGER WIDTH,DIGITS);
BEGIN
	STPTR←STPTR+1;
	GETFORMAT(W[STPTR],D[STPTR]);
	SETFORMAT(WIDTH,DIGITS);
END;

PROCEDURE GFORMAT;
BEGIN
	SETFORMAT(W[STPTR],D[STPTR]);
	STPTR←STPTR-1;
END;

STRING PROCEDURE CVFAL(REAL R);
COMMENT NEED THIS SILLY ROUTINE BECAUSE CVF PRINTS 0.1 AS .1 AND -0.1 AS -.1 ;
BEGIN
   STRING S;
   S←CVF(R);
   IF S[2 FOR 1]="." THEN RETURN(S[1 FOR 1]&"0"&S[2 TO ∞]) ELSE RETURN(S);
END;
!	dimenstring;

INTERNAL SIMPLE STRING PROCEDURE DSTRING(INTEGER I; STRING SPOS,SNEG);
	BEGIN  INTEGER J; STRING S,SS;
	IF I=0 THEN RETURN(NULL)
	   ELSE IF I>0 THEN SS←SPOS ELSE BEGIN SS←SNEG; I←-I; END;
	S←NULL;
	FOR J←1 STEP 1 UNTIL I DO S←S&SS;
	RETURN(S);
	END;

STRING PROCEDURE DIMENSTRING(RPTR(DIMENS)D);
	BEGIN STRING S; S←NULL;
	S←S&DSTRING(DIMENS:DISTANCE[D],"*INCH","/INCH");
	S←S&DSTRING(DIMENS:TIME[D],"*SEC","/SEC");
	S←S&DSTRING(DIMENS:FORCE[D],"*OUNCES","/OUNCES");
	S←S&DSTRING(DIMENS:ANGLE[D],"*DEG","/DEG");
	RETURN(S);
	END;
! display: cvxs,cvxv,cvxr,cvxt,cvxf,cvxm,cvxp,cvxstr;

STRING PROCEDURE CVXS(REAL R; RPTR(DIMENS)D; INTEGER MODE(TABLE_D));
	BEGIN
	STRING S1;
	IF MODE=TABLE_D THEN SFORMAT(0,2) ELSE SFORMAT(0,3);
	S1←CVFAL(R);
	GFORMAT;
	IF MODE=FILE_D THEN S1←S1&DIMENSTRING(D);
	RETURN(SCAN(S1,$BSKTAB,$BRCHR));	! to cancel the spaces;
	END;

	! returns a string with the rotation part;

SIMPLE STRING PROCEDURE CVXR(REAL ARRAY XF;INTEGER MODE(TABLE_D));
	BEGIN
	REAL W,PH,TH; STRING RS,SCA;
	STRING BEG,MID,EN;
	SIMPLE STRING PROCEDURE ROTFORM(STRING AXIS;REAL W);
		RETURN(BEG&AXIS&MID&CVFAL(W)&EN);

	IF MODE=TABLE_D
	THEN	BEGIN BEG←"("; MID←","; EN←")" END
	ELSE	BEGIN BEG←"ROT("; MID←"HAT,"; EN←"*DEG)" END;

	TH←XF[4];PH←XF[5];W←XF[6]; RS←SCA←NULL;
	SFORMAT(0,1);
	IF ABS(TH)>$EPS THEN 
		BEGIN RS←RS&ROTFORM("Z",TH); SCA←"*"; END;
	IF ABS(PH)>$EPS THEN
		BEGIN RS←RS&SCA&ROTFORM("Y",PH); SCA←"*"; END;
	IF ABS(W)>$EPS THEN
		BEGIN RS←RS&SCA&ROTFORM("Z",W); SCA←"*"; END;
	IF LENGTH(SCA)=0 THEN RS←"NILROT";
	GFORMAT;
	RETURN(SCAN(RS,$BSKTAB,$BRCHR));
	END;

	! returns a string with the vector part for frame assignments;

STRING PROCEDURE CVXV(REAL X,Y,Z;RPTR(DIMENS)D;INTEGER MODE(TABLE_D));
	BEGIN
	STRING S,VECTOR,INCH;
	IF MODE=FILE_D OR MODE=EDIT_D THEN
		BEGIN VECTOR←"VECTOR"; INCH←DIMENSTRING(D); SFORMAT(0,3); END
	ELSE BEGIN VECTOR←INCH←NULL; SFORMAT(0,2); END;
	IF ABS(X)<$EPS AND ABS(Y)<$EPS AND ABS(Z)<$EPS
	   THEN S←"NILVECT"&INCH
	   ELSE S←" "&VECTOR&"("&CVFAL(X)&","&CVFAL(Y)&","&CVFAL(Z)
			&")"&INCH;
	GFORMAT;
	RETURN(SCAN(S,$BSKTAB,$BRCHR));
	END;

STRING PROCEDURE CVTR(REAL ARRAY XF;RPTR(DIMENS)D;INTEGER MODE(TABLE_D));
	BEGIN				
	STRING S;
	S←"("&CVXR(XF,MODE)&","&CVXV(XF[1],XF[2],XF[3],D,MODE)&")";
	RETURN(SCAN(S,$BSKTAB,$BRCHR));
	END;

STRING PROCEDURE CVXT(REAL ARRAY XF;RPTR(DIMENS)D;INTEGER MODE(TABLE_D));
	IF MODE=TABLE_D THEN RETURN(CVTR(XF,D,MODE))
		ELSE RETURN("TRANS"&CVTR(XF,D,MODE));

STRING PROCEDURE CVXF(REAL ARRAY XF; RPTR(DIMENS)D; INTEGER MODE(TABLE_D));
	IF MODE=TABLE_D THEN RETURN(CVTR(XF,D,MODE))
		ELSE RETURN("FRAME"&CVTR(XF,D,MODE));

SIMPLE STRING PROCEDURE CVXM(STRING S; INTEGER MODE(TABLE_D));
	BEGIN INTEGER BRCHAR; STRING S1,S2;
	S1←"⊂"&SCAN(S,$RBTAB,BRCHAR)&"⊃";
	IF MODE≠TABLE_D THEN RETURN(S1);
	S2←SCAN(S1,$CRTAB,BRCHAR);
	WHILE S1 DO S2←S2&CRLF&"   "&SCAN(S1,$CRTAB,BRCHAR);
	RETURN(S2);
	END;

SIMPLE STRING PROCEDURE CVXP(STRING S; INTEGER MODE(TABLE_D));
	RETURN(S);

SIMPLE STRING PROCEDURE CVXSTR(STRING S; INTEGER MODE(TABLE_D));
	IF S THEN RETURN(S) ELSE RETURN("NULL");
! cvx,cvsym,cvssym,cvexpr;
STRING PROCEDURE CVX(RANY T; INTEGER TYPE; RPTR(DIMENS)D; INTEGER MODE(TABLE_D));
	BEGIN "cvx"
	STRING S;
	CASE TYPE OF
		BEGIN
		[#SC] S←CVXS(SCALAR:VALUE[T],D,MODE);
		[#VT] S←CVXV(VECTOR:XC[T],VECTOR:YC[T],VECTOR:ZC[T],D,MODE);
		[#RT] S←CVXR(ROT:XF[T],MODE);
		[#TR] S←CVXT(TRANS:XF[T],D,MODE);
		[#FR] S←CVXF(FRAME:XF[T],D,MODE);
		[#MC] S←CVXM(MACRO:BODY[T],MODE);
		[#PR] S←CVXP(PROC:BODY[T],MODE);
		[#ST] S←CVXSTR(PSTRING:VALUE[T],MODE)
		END;
	RETURN(S);
	END "cvx";

INTERNAL STRING PROCEDURE CVEXPR(RPTR(EXPR$)EX; INTEGER MODE(TABLE_D));
	RETURN(CVX($EVALEXP(EX),EXPR$:TYPE[EX],EXPR$:DIMENS[EX],MODE));

INTERNAL STRING PROCEDURE CVSYM(RPTR(SYMBOL)SYM; INTEGER MODE(TABLE_D));
! only gives the data part ;
CASE SYMBOL:ACCESS[SYM] OF
	BEGIN
	[#PROCEDURE]
	    RETURN(CVX(SYMBOL:OBJECT[SYM],#PR,SYMBOL:DIMENS[SYM],MODE));
	[#SIMPLE][#ARRAY_ELEMENT]
	    IF SYMBOL:TYPE[SYM]=#MC OR ($ELFABORTED AND (MODE=FILE_D))
		THEN
	    RETURN(CVX(SYMBOL:OBJECT[SYM],SYMBOL:TYPE[SYM],
				SYMBOL:DIMENS[SYM],MODE))
		ELSE
	    IF SYMBOL:TYPE[SYM]=#EV THEN RETURN ("")
		ELSE
		BEGIN
		IF MODE=FILE_D THEN $EVAL11(SYM);
		RETURN(CVX(SYMBOL:OBJECT[SYM],SYMBOL:TYPE[SYM],
				SYMBOL:DIMENS[SYM],MODE));
		END;
	[#ARRAY]
	    ERROR("CVSYM ERROR: cannot handle ARRAYS")
	END;
	    
INTERNAL STRING PROCEDURE CVSSYM(RPTR(SYMBOL)SYM; INTEGER MODE(TABLE_D));
! gives symbol and appends data part ;
CASE SYMBOL:ACCESS[SYM] OF
    BEGIN
    [#SIMPLE][#PROCEDURE][#ARRAY_ELEMENT]
	BEGIN
	STRING HEAD;
	IF #SC≤SYMBOL:TYPE[SYM]≤#EV
	THEN HEAD←" "&SYMBOL:PNAME[SYM]&" "
	ELSE IF SYMBOL:TYPE[SYM]=#MC
	    THEN HEAD←" "&MACRO:HEAD[SYMBOL:OBJECT[SYM]]&(IF MODE=TABLE_D THEN
		" " ELSE " = ")
	    ELSE HEAD←" ";	! the head of the procedure is in body;
	RETURN(HEAD&CVSYM(SYM,MODE))
	END;
    [#ARRAY] ERROR("CVSSYM ERROR: cannot handle ARRAYS")
    END;

END "FORMAT"